//
// Created by lz on 2021/2/3.
//

// Taken from PCRE pcre_stringpiece.h
//
// Copyright (c) 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: Sanjay Ghemawat
//
// A string like object that points into another piece of memory.
// Useful for providing an interface that allows clients to easily
// pass in either a "const char*" or a "string".
//
// Arghh!  I wish C++ literals were automatically of type "string".

#ifndef MYWEBLIB_STRINGPIECE_H
#define MYWEBLIB_STRINGPIECE_H

#include <string.h>
#include <iosfwd> //for ostream forward-declaration
#include "Types.h"


namespace lzweb {
    class StringArg {
    public:
        StringArg(const char *str)
                : str_(str) {}

        StringArg(const string &str)
                : str_(str.c_str()) {}

        const char *c_str() { return str_; }

    private:
        const char *str_;
    };


    //一个字符串数组的代理类，即接管一个字符串的读操作，不修改其对象本身的内容，以及其生命周期
    class StringPiece {
    private:
        const char *ptr_;
        int length_;
    public:
        StringPiece()
                : ptr_(nullptr), length_(0) {}

        StringPiece(const char *str)
                : ptr_(str), length_(static_cast<int >(strlen(ptr_))) {}

        StringPiece(const unsigned char *str)
                : ptr_(reinterpret_cast<const char *>(str)),
                  length_(static_cast<int>(strlen(ptr_))) {}

        StringPiece(const string &str)
                : ptr_(str.data()), length_(static_cast<int>(strlen(ptr_))) {}

        StringPiece(const char *offset, int len)
                : ptr_(offset), length_(len) {}


        const char *data() const { return ptr_; }

        int size() const { return length_; }

        bool empty() const { return length_ == 0; }

        const char *begin() const { return ptr_; }

        const char *end() const { return ptr_ + length_; }

        void clear() {
            ptr_ = nullptr;
            length_ = 0;
        }

        void set(const char *buffer, int len) {
            ptr_ = buffer;
            length_ = len;
        }

        void set(const char *str) {
            ptr_ = str;
            length_ = static_cast<int >(strlen(str));
        }

        void set(const void *buffer, int len) {
            ptr_ = reinterpret_cast<const char *>(buffer);
            length_ = len;
        }

        char operator[](int i) const { return ptr_[i]; }

        void remove_prefix(int n) {
            ptr_ += n;
            length_ -= n;
        }

        void remove_suffix(int n) {
            length_ -= n;
        }

        bool operator==(const StringPiece &x) const {
            return ((length_ == x.length_) &&
                    (memcmp(ptr_, x.ptr_, length_) == 0));
        }

        bool operator!=(const StringPiece &x) const {
            return !(*this == x);
        }

#define STRINGPIECE_BINARY_PREDICATE(cmp, auxcmp) \
        bool operator cmp(const StringPiece &x) const{ \
            int r = memcmp(ptr_,x.ptr_,length_ < x.length_ ? length_:x.length_); \
            return  ((r auxcmp 0) || ((r==0)&&(length_ cmp x.length_))) ;\
        }

        STRINGPIECE_BINARY_PREDICATE(<, <);

        STRINGPIECE_BINARY_PREDICATE(<=, <);

        STRINGPIECE_BINARY_PREDICATE(>=, >);

        STRINGPIECE_BINARY_PREDICATE(>, >);

#undef STRINGPIECE_BINARY_PREDICATE

        int compare(const StringPiece &x) const{
            int r = memcmp(ptr_, x.ptr_, length_ < x.length_ ? length_ : x.length_);
            if (r == 0) {
                if(length_<x.length_) r =  -1;
                else if(length_>x.length_) r = +1;
            }

            return r;
        }

        string  as_string()const{
            return string(data(),size());
        }

        void CopyToString(string* target) const{
            // assign() replace the contents of the string
            target->assign(ptr_,length_);
        }

        bool starts_with(const StringPiece& x) const{
            return ((length_ >= x.length_) && (memcmp(ptr_,x.ptr_,x.length_) == 0));
        }

    };
} // namespace lzweb

#ifdef HAVE_TYPE_TRAITS
// This makes vector<StringPiece> really fast for some STL implementations
template<> struct __type_traits<muduo::StringPiece> {
  typedef __true_type    has_trivial_default_constructor;
  typedef __true_type    has_trivial_copy_constructor;
  typedef __true_type    has_trivial_assignment_operator;
  typedef __true_type    has_trivial_destructor;
  typedef __true_type    is_POD_type;
};
#endif

// allow StringPiece to be logged
std::ostream& operator<<(std::ostream& o, const lzweb::StringPiece& piece);

#endif //MYWEBLIB_STRINGPIECE_H
